home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / LVSWIN31.ARJ / LVSWIN.DOC < prev    next >
Text File  |  1992-02-26  |  98KB  |  2,481 lines
  1.                                LVS Windows (tm)
  2.                                      v3.1
  3.  
  4.                           The C++ Window Class System
  5.                                       by
  6.                               Lake View Software
  7.  
  8.  
  9.                  Copyright (c) 1991, 1992, Lake View Software
  10.                               All Rights Reserved
  11.  
  12.  
  13.                             Features of LVS Windows
  14.  
  15.  
  16.             - Powerful windowing system.  Allows as many window objects as
  17.             memory permits.  Windows objects can be stacked, tiled, moved,
  18.             resized, and changed in many other ways.  There is a whole
  19.             assortment of various input and output messages to interact with
  20.             windows.  All windows are active and can be written to at any time.
  21.  
  22.             - All windows can be virtual.  This allows you to create windows
  23.             larger than the screen.  Data entry screens automatically pan around
  24.             the virtual window as the user moves the cursor.  The user can also
  25.             use the mouse to pan a window.
  26.  
  27.             - Multi-field formatted data entry.  You can create data entry forms
  28.             that consist of one or more input fields.  You have full control
  29.             over user input and can tie validation functions into each input
  30.             field.
  31.  
  32.             - As of version 1.6, there are functions specific designed to
  33.             support the Paradox Engine.  Paradox Engine is a trade mark of
  34.             Borland.  These functions allow you to read user input directly from
  35.             a Paradox Record Buffer.  Large model only.
  36.  
  37.             - Moving bar menus.  You can easily create pop-up, pull-down, and
  38.             Lotus-style menus, as well as any other custom menu that you can
  39.             define.  All with automatic mouse support.
  40.  
  41.             - Scrollable pick menus.  Allow you to pick one item from a list of
  42.             items.  Also with mouse support.
  43.  
  44.             - Several video output methods.  These include direct screen
  45.             writing, CGA snow reduction, and video BIOS writing.  28 and 50 line
  46.             modes available on color VGA screens.
  47.  
  48.             - Keyboard management routines.  Allows you to tie keystrokes to
  49.             functions, and specify a function to be called while waiting for a
  50.             keypress.
  51.  
  52.             - Full mouse support is available with all these routines.  One
  53.             function call and the mouse is enabled.  No other work necessary,
  54.             though you can manipulate mickey if you wish.
  55.  
  56.                           Registration Information
  57.  
  58.  
  59.  
  60.       LVS Windows is distributed as User-Supported software.  You are free to
  61.       copy and distribute this software freely*, however, if you find it of use
  62.       to you, you are encouraged to register your copy.  Registering your copy
  63.       of the software helps the author continue to provide professional quality
  64.       software at very reasonable prices.
  65.  
  66.       *** Only Small Memory Model Libraries may be distributed ***
  67.       *** with out written consent from Lake View Software *****
  68.  
  69.       The Full Registration is $50.00 and includes all memory models plus full
  70.       library source.  The library is written in C++ and is compatible with
  71.       Turbo C++ v1.x, Borland C++ v2.0 & 3.0, and Zortech C++ v3.0.  All window
  72.       classes use the same low-level C functions.  This allows easy porting to
  73.       other operating systems.
  74.  
  75.       All materials are shipped on 5.25-inch or 3.5-inch floppy diskettes. 
  76.       Please specify when ordering.
  77.  
  78.       U.S. orders add $4.00 shipping & handling.
  79.  
  80.       Non-U.S. orders need to include $5.00 extra to cover additional shipping
  81.       and handling charges.  Checks and money orders must be drawn on a U.S.
  82.       bank.  Total of $59.00 US dollars
  83.       
  84.       To order direct from LVS, Please send all payments payable in U.S. 
  85.       Dollars to:
  86.  
  87.                       ╔════════════════════════════════╗
  88.                       ║       Lake View Software       ║
  89.                       ║       4321 Harborough Rd.      ║
  90.                       ║       Columbus, OH 43220       ║
  91.                       ╚════════════════════════════════╝
  92.  
  93.       All major upgrades will be available for only $15.00 + $4.00 s/h.
  94.       Registered users will be notified of all major upgrades.
  95.  
  96.       All non-major upgrades will be available for a $4.00 shipping fee.
  97.       All new releases will be posted on CompuServe in the BPROGB forum.
  98.  
  99.       Please report any errors (BUGS) or suggestions
  100.       to Lake View Software or:
  101.  
  102.                   CompuServe:  70004,524
  103.  
  104.  
  105.       You can order directly from Lake View Software with a check or money
  106.       order,  or from the Public (software) Library with your MC, Visa, AMX or
  107.       Discover card by  calling 800-2424-PsL, P.O. Box 35705, Houston, Texas
  108.       77235-5705.  PsL is for ordering only.  For information about dealer
  109.       pricing, volume discounts, site licensing, shipping of product, returns,
  110.       latest version number or other technical information,  Send your request
  111.       to Lake View Software at the above address or send an Easy Plex on
  112.       CompuServe at [70004,524].
  113.  
  114.       When ordering from Public (software) Library refer to this product number: 
  115.       #10224.
  116.                                     Files
  117.  
  118.  
  119.       LVSWIN.WP         This file, in Word Perfect 5.1 format.
  120.       LVSWIN.DOC        This file in DOS text format.
  121.  
  122.       LVSWIN_S.LIB      LVS small model library.  You must link to this file to
  123.                         use any of the windows object messages.  The demo is
  124.                         distributed with the Small model library only.
  125.  
  126.       LVSWIN.HPP        LVSwin class definitions.  Must be #included in your
  127.                         program to link with winobj.lib.  This will also include
  128.                         LVSwin.h.  Always use the header files that come with
  129.                         the library, discard previous versions.
  130.  
  131.       LVSMENU.HPP       WinMenu class definitions.  Must be #included in any
  132.                         program using the menuing system.  This header file will
  133.                         include lvswin.hpp with it.
  134.  
  135.       LVSPICK.HPP       WinPick class definitions.  Will include winobj.hpp with
  136.                         it.
  137.  
  138.       LVSWIN.H          Defines low level .C functions used by LVSwin_?.lib. 
  139.                         Also defines various window function options and key
  140.                         strokes.  This is automatically included with LVSwin.hpp
  141.                         or any other winobj class headers.
  142.  
  143.  
  144.       DEMO.CPP          Source code for the demo.
  145.       DEMO2.CPP         Demo programs written using LVS Windows.  These demos
  146.       DEMO3.CPP         uses many of the key features of LVS and makes a good
  147.       DEMO4.CPP         working example.  See demo.doc for instructions on
  148.                         building/using the demos.
  149.  
  150.                           Declaring a Window Object
  151.  
  152.  
  153.  
  154. WinObj <Object> (int v_h=0,int v_w=0)
  155.  
  156.       v_h   Virtual height of the window.  Default is 0  If declared as the
  157.             default (0) then the virtual height will be set to the height of the
  158.             window when it is opened.
  159.  
  160.       v_w   Virtual width of the window.  Default is 0  If declared as the
  161.             default (0) then the virtual width will be set to the width of the
  162.             window when it is opened.
  163.  
  164.             The virtual height and width can be changed any time the window is
  165.             not opened, using the set_virtual message.
  166.  
  167.             EXAMPLE:
  168.                         WinObj window_a;
  169.                         main()
  170.                         {
  171.                               WinObj window_b ( 100, 100);
  172.                               ~ ~ ~ ~
  173.                               ~ ~ ~
  174.                               ~ ~ ~
  175.                         }
  176.                                WinObj Routines
  177.  
  178.  
  179.  
  180. box
  181.       Draw a box in the window.  The current window attribute will be used.  The
  182.       cursor position will be unchanged.
  183.  
  184.       USAGE:      void box (int sr, int sc, int er, int ec, int type =
  185.                   W_SINGLE);
  186.  
  187.             sr = start row.
  188.             sc = start column.
  189.             er = end row.
  190.             ec = end column.
  191.             type = Box style.  Can be any of the valid border styles.
  192.  
  193. ========================================
  194.  
  195. center
  196.       Centers a string in the virtual window, using the current attribute.
  197.  
  198.       USAGE:      int center (int y, char *str);
  199.  
  200.  
  201.       RETURNS:    W_OK, W_NOTOPEN
  202. ========================================
  203. change_border
  204.       Changes the border style for the window object.  Optionally changes the
  205.       border color.
  206.  
  207.       USAGE:      void change_border (int type, int color = -1);
  208.  
  209.       Required arguments.
  210.             type        new border type.  Use any of the types below.
  211.                         W_SPACES          W_SINDOU
  212.                         W_DOUBLE          W_SINGLE
  213.                         W_DOUSIN          W_SOLID
  214.  
  215.       Optional arguments.
  216.             color       new border attribute.  Default is -1 which will leave
  217.                         border color unchanged.
  218.  
  219.       EXAMPLE:
  220.             main()
  221.             {
  222.                   WinObj a;
  223.                   a.open (12,12,20,50);
  224.                   ~~~
  225.                   a.change_border ( W_DOUSIN, _BLUE|WHITE);
  226.                   ~~
  227.                   ~
  228.                   a.close();
  229.             }
  230. =======================================
  231. close
  232.       Close the window object.  A window object can be opened and closed as
  233.       often as you like through its life.  A window will automatically be closed
  234.       when it leaves the scope of your application.
  235.  
  236.       USAGE:      void close();
  237.  
  238.       EXAMPLE:
  239.             main()
  240.             {
  241.                   WinObj a;
  242.                   a.open (12,12,20,50);
  243.                   ~~~
  244.                   ~~
  245.                   ~
  246.                   a.close();
  247.                   a.open (10,10,15,35,W_SPACES,_BLUE|GREEN);
  248.                   a.close();
  249.             }
  250.  
  251. =======================================
  252. clr_eol
  253.       Clears the window to the end of the current line.  The cursor position is
  254.       not changed.
  255.  
  256.       USAGE:      void clr_eol ();
  257.  
  258. =======================================
  259. clr_win
  260.       Clears the window with the current attribute.
  261.  
  262.       USAGE:      void clr_win ();
  263.  
  264.       EXAMPLE:
  265.             main()
  266.             {
  267.                   WinObj a;
  268.                   a.open (1,1,12,40);
  269.                   a.printf ("This is a test string.");
  270.                   a.set_attr (_BLUE|WHITE);
  271.                   a.clr_win ();
  272.                   a.close ();
  273.             }
  274. =======================================
  275. del_line
  276.       Deletes a line in the window object.  All text below the line is pulled up
  277.       and a blank line is inserted at the end.  The cursor position will not be
  278.       changed.
  279.  
  280.       USAGE:      void del_line (int y);
  281.  
  282.             y     row to be deleted.
  283.  
  284. =======================================
  285. gotoxy
  286.       Move the cursor inside the window.
  287.  
  288.       USAGE:      void gotoxy (int y = 0, int x = 0);
  289.  
  290.       Optional arguments.
  291.             y     New y location.  default to origin.  If y is 1 greater than
  292.                   max_y the window will scroll up 1 line and a blank line will
  293.                   be inserted at the end.
  294.  
  295.             x     New x location.  default to origin.
  296.  
  297.       EXAMPLE:
  298.             main()
  299.             {
  300.                   WinObj a;
  301.                   a.open (12,12,20,50);
  302.                   ~~~
  303.                   a.gotoxy(5,5);
  304.                   ~
  305.                   a.close();
  306.             }
  307. =======================================
  308. hide
  309.       Hides the window object.  None of the window contents will be changed.  
  310.  
  311.       A window may be hidden before it is opened. This will allow you to build
  312.       the window at one time and unhide it later.
  313.  
  314.       USAGE:      void hide ();
  315.  
  316. =======================================
  317. ins_line
  318.       Insert a line in the window object.  All text from the line down is pushed
  319.       down. The last line will be pushed out of the window.  A blank line will
  320.       be inserted.  The cursor position will not change.
  321.  
  322.       USAGE:      void ins_line (int y);
  323.  
  324.             y     row number to be inserted.
  325.  
  326. =======================================
  327. move
  328.       Moves a window on the screen.  The window contents are left in tact.  The
  329.       window does not have to be active to move.  It will slide under other
  330.       windows if needed.
  331.  
  332.       USAGE:      int move (int start_y, int start_x);
  333.  
  334.             start y/x   new start coordinates for the upper left of the window
  335.                         object.
  336.  
  337.       RETURNS:    W_OK, or W_ERROR if your coordinates cause the window to move
  338.                   off the screen.
  339.  
  340. =======================================
  341. open
  342.       Opens a window object on the screen.
  343.  
  344.       USAGE:      int open (int sr,int sc,int er,int ec,
  345.                               int btype=W_DOUBLE,
  346.                               int wattr=_BLACK|LGREY,
  347.                               int battr=_BLACK|LGREY)
  348.  
  349.       RETURNS:    0 if successful.
  350.  
  351.       Required arguments.
  352.             sr    Start row for the window.
  353.             sc    Start column for the window.
  354.             er    End row for the window.
  355.             ec    End column for the window.
  356.  
  357.       Optional arguments.
  358.             btype Border type.  default is W_DOUBLE.
  359.                   W_NOBORDER        W_SPACES
  360.                   W_DOUBLE          W_SINGLE
  361.                   W_DOUSIN          W_SOLID
  362.                   W_SINDOU
  363.             wattr Window attribute. default is _BLACK|LGREY.
  364.             battr Border attribute. default is _BLACK|LGREY.
  365.  
  366.       EXAMPLE:
  367.             main()
  368.             {
  369.                   WinObj a;
  370.                   a.open (12,12,20,50);
  371.                   ~~~
  372.                   ~~
  373.                   ~
  374.             }
  375.  
  376. =======================================
  377. pan
  378.  
  379.       Adjust the virtual window by delta number of characters.  The window
  380.       automatically adjusts its pan location when the user moves the cursor. 
  381.       This keeps the cursor always in the visible window.  You can use pan to
  382.       adjust it manually if you need.
  383.  
  384.       USAGE:      int pan (int delta_y, int delta_x);
  385.  
  386.             delta_y,    the change in the x and y start coordinate.
  387.             delta_x
  388.  
  389.       RETURNS:    W_OK, W_NOTOPEN
  390.  
  391.       SEE:  set_pan()
  392.  
  393.  
  394. =======================================
  395. printf
  396.  
  397.       Display a formatted string in the window at the current cursor position. 
  398.       This function works very much like the printf function in C.  This also
  399.       has an optional xy coordinates.
  400.  
  401.       If the y coordinate is 1 greater than max_y the window will scroll up 1
  402.       line and the new text will be inserted on a new blank line.
  403.  
  404.       USAGE:      void printf (char *,...);
  405.                   void printf ( int y, int x, char *,...);
  406.  
  407.       EXAMPLE:
  408.             main()
  409.             {
  410.                   WinObj a;
  411.                   int i = 2;
  412.                   a.open (12,12,20,50);
  413.                   a.gotoxy (5,5);
  414.                   a.printf ("( 2 + 2 = %d )",i+2);
  415.                   a.gotoxy ();
  416.                   a.printf ("This is the window origin.");
  417.                   ~
  418.                   a.close ();
  419.             }
  420.  
  421. =======================================
  422. putch
  423.       Display a single character in the window.  Cursor position will be updated
  424.       to the next window character.  The current window attribute will be used.
  425.  
  426.             USAGE:      void putch (char ch, int translate=W_OFF);
  427.                         void putch (int y, int x, char ch, int trans=W_OFF);
  428.  
  429.             translate   W_ON, LF will cause a cr/lf.  CR will be ignored.  \t
  430.                         will tab to the next tab position.  The default is to
  431.                         not translate.
  432. =======================================
  433. puts
  434.       Display a simple string to the window.  Cursor position will be updated to
  435.       the next window character.  The current window attribute will be used.
  436.  
  437.             USAGE:      void puts (char *str, int translate=W_ON);
  438.                         void puts (int y, int x, char *str, translate=W_ON);
  439.  
  440.             translate   W_ON, LF will cause a cr/lf.  CR will be ignored.  \t
  441.                         will tab to the next tab position.  The default is to
  442.                         not translate.
  443. =======================================
  444. set_active
  445.       Brings a window to the surface.  This will also unhide a function. 
  446.       Set_active is called each time you input a keystroke from a window.
  447.  
  448.       USAGE:      void set_active ();
  449.  
  450. =======================================
  451. set_attr
  452.       Sets a new default attribute for the window object.
  453.  
  454.       USAGE:      int set_attr (int new_attr);
  455.  
  456.       Required arguments.
  457.             new_attr    New attribute for window.  Can be any legal color
  458.  
  459.                         Mono screens will be remapped to use only black on white
  460.                         or white on black.  This is automatic.
  461.  
  462.       RETURNS:    previous attribute.
  463.  
  464.  
  465.       EXAMPLE:
  466.       main()
  467.       {
  468.             WinObj a;
  469.             a.open (12,12,20,50);
  470.             ~~~
  471.             a.new_attr (_RED|YELLOW);  // All characters from this point will
  472.                                           be displayed as yellow on red.
  473.             ~~~
  474.             ~~
  475.             ~
  476.             a.close();
  477.       }
  478. =======================================
  479. set_attr
  480.       changes the attribute for a region in a window.
  481.  
  482.       USAGE:      void set_attr (int new_attr, int y, int x, int cnt = 1);
  483.  
  484.             new_attr    new attribute for the region.
  485.             y,x         start y,x coordinates.
  486.             cnt         number of characters to change.  default is 1.
  487.  
  488. =======================================
  489. set_fill
  490.       Set the window fill character.  Default is spaces.
  491.  
  492.       USAGE:      void set_fill (char ch);
  493.  
  494. =======================================
  495.  
  496.  
  497. set_virtual
  498.       Changes the virtual height and width of a window.  This can only be done
  499.       when the window is closed.
  500.       USAGE:      int set_virtual (int vh, int vw);
  501.  
  502.             vh    new virtual height.
  503.             vw    new virtual width.
  504.  
  505.       Setting the vh and/or vw to zero causes them to be automatically set when
  506.       open is called.
  507.  
  508.       RETURNS:    W_OK or W_OPENED
  509.  
  510. =======================================
  511. size
  512.       Set a new size for the displayed window object.  The virtual height and
  513.       width are left unchanged.  This means you can not make a window larger
  514.       than its virtual sizes.
  515.  
  516.       USAGE:      int size (int new_height, int new_width);
  517.  
  518.       RETURNS:    W_OK, or W_ERROR if your new size is less than 1.
  519.  
  520. =======================================
  521. title
  522.       Add, change or remove a window title.  The window title will have the same
  523.       attribute as the window border.
  524.  
  525.       USAGE:      void title (char *str, int position = W_CENTER);
  526.  
  527.       Required arguments.
  528.             str         Title string to display.  If NULL then the window title
  529.                         will be removed.
  530.       Optional arguments.
  531.             position    Position of the title.  Default is W_CENTER.
  532.                         W_CENTER    W_LEFT        W_RIGHT
  533.  
  534.       EXAMPLE:
  535.             main()
  536.             {
  537.                   WinObj a;
  538.                   a.open (12,12,20,50);
  539.                   a.title ("[ Window 1 ]", W_LEFT);
  540.                   ~~~
  541.                   ~
  542.                   a.close();
  543.             }
  544. =======================================
  545. unhide
  546.       Unhide a hidden window object.
  547.  
  548.       USAGE:      void unhide ();
  549.  
  550. =======================================
  551. update
  552.       Update the window object.  This will display all buffered output.  The
  553.       window does not have to be the active window to be updated.
  554.       USAGE:      void update ();
  555.  
  556.       EXAMPLE:    see printf
  557.  
  558. =======================================
  559. update_all
  560.       Update all non hidden, open windows.  The order of active windows will not
  561.       change.  You can call this method from any window object.  This will be
  562.       most useful if your screen is damaged by some external program.
  563.  
  564.       USAGE:      void update_all ();
  565. =======================================
  566. allow_user_moves
  567.       Turn the users ability to move/resize/scroll a window with the mouse.  By
  568.       default the user has the ability to adjust any window with a border.
  569.  
  570.       USAGE:      void allow_user_moves (int true_false)
  571.  
  572.                   TRUE is the default.  FALSE prevents the user from adjusting
  573.                   that window.
  574.                                The << operator
  575.  
  576.       The << operator can be used for window output.  This is handy for those
  577.       who are use to the C++ ostream library.  The << operator has an override
  578.       for all the basic C data types.  The gotoxy routine has also been modified
  579.       to return a WinObj& which allows you to position the cursor and output
  580.       with << on the same line.
  581.  
  582.       EXAMPLES:
  583.  
  584.             WinObj w;
  585.  
  586.             w.open (.....);
  587.  
  588.             w.gotoxy (y, x) << "The answer is " << x;
  589.             w << '\n' << string << number << string << '\n';
  590.             w << "12 + 12 = " << 12+12;
  591.       
  592.       Also see the Demo program for examples using the << operator. Mouse Routines
  593.  
  594.  
  595.       You must have a MicroSoft compatible mouse with mouse.com loaded for mouse
  596.       support.  The mouse has 2 modes of operation.  The program can switch
  597.       between these modes at any time.
  598.  
  599.       To activate the mouse in your program you just make one function call:
  600.  
  601.             Win_mouse_mode (mode);
  602.  
  603.                   mode:
  604.                         M_FULL            full mouse support
  605.                         M_SIMPLE          simple mouse support
  606.                         M_NONE            no mouse support
  607.  
  608.       This routine is defined in WinMouse.HPP.  The definitions of the support
  609.       modes are listed below.
  610.  
  611.  
  612.       Simple support:
  613.             - there will be no mouse cursor present.
  614.  
  615.             - moveing the mouse is equal to using the arrow keys.
  616.  
  617.             - the right mouse button equates to the ESC key.
  618.  
  619.             - the left mouse button equates to ENTER.
  620.  
  621.       Full support:
  622.             - there will be a mouse cursor.
  623.  
  624.             - the right mouse button equates to the ESC key.
  625.  
  626.             - to make a menu selection, click the left button on the item of
  627.             your choice.
  628.  
  629.             - you can move any bordered window.  Move the mouse cursor to the
  630.             top border of the window you wish to move.  Press and hold the left
  631.             mouse button.  The top left edge of the window will follow the mouse
  632.             cursor until you release the left button.
  633.  
  634.             - you can resize any bordered window.  Move the mouse cursor to the
  635.             bottom right corner of the window.  Press and hold the left mouse
  636.             button.  You can now make the window shrink and grow by moving the
  637.             mouse.  The max size for any window is its virtual size.  Any window
  638.             which is smaller than its virtual size will have panning arrows on
  639.             the left and/or bottom border.
  640.  
  641.             - you can pan a window which has a virtual size larger then its
  642.             fisical size.  Just click on the panning arrows on the left or top
  643.             border.  Holding down on the left button will cause the window to
  644.             pan until the end.
  645.  
  646.             - you can scroll a pick list by clicking on the up/down arrows on
  647.             the left border of the window.
  648.  
  649.             - you can move the text cursor in a data entry window by clicking on
  650.             the field of your choice.
  651.  
  652.       The mouse support is created with a mouse class.  The class object is
  653.       declared in WinMouse.CPP.  This is a global object so you have access to
  654.       it, but be sure you understand the WinMouse class before accessing the
  655.       object directly.
  656.             The Object is declared as   WinMouse Win_mouse (M_NONE);
  657.  
  658.       You can safely use the following routines with LVS Windows.
  659.  
  660. Win_mouse_mode
  661.       Use this routine to change the mouse mode.  You can change the mode at any
  662.       time during your program.
  663.  
  664.       USAGE:      int Win_mouse_mode (int mode);
  665.  
  666.             mode  M_FULL
  667.                   M_SIMPLE
  668.                   M_NONE            turns mouse off
  669.  
  670.       RETURNS:    0 if no mouse detected
  671.                   -1 if mouse is present
  672.  
  673. =======================================
  674. set_mouseroutine
  675.       Each WinObj object is allowed a mouse routine.  This routine will be
  676.       called whenever a mouse click is detected in the bound of the window.  The
  677.       routine will even be called when the window is not the active window.  By
  678.       default each window object has no mouse routine.
  679.  
  680.       USAGE:      mouse_routine_t set_mouseroutine (mouse_routine_t);
  681.  
  682.             mouse_routine_t   is defined as a void function which takes two
  683.                               integers as arguments.
  684.                               ie:  void Routine (int y, int x);
  685.  
  686.       RETURNS:    a pointer to the previous routine.  Usualy you will ignore
  687.                   this.
  688.  
  689.       NOTES:      The Y/X values passed to the routine are the x/y coordinates
  690.                   within the window.  They are the windows coordinates not the
  691.                   screen coordinates.
  692.  
  693.       EXAMPLE:
  694.             void My_Mouse_Routine (int y, int x)
  695.             {
  696.                   Do something with the mouse click here.
  697.                   You have been passed the coordinates of the click
  698.                   so be creative.
  699.             }
  700.  
  701.             void main ()
  702.             {
  703.                   WinObj w;
  704.  
  705.                   Win_mouse_mode (M_FULL);
  706.  
  707.                   w.open (.....);
  708.                   w.set_mouseroutine (My_Mouse_Routine);
  709.                   .......
  710.                   .......
  711.             }                   Input Routines
  712.  
  713.  
  714. before
  715.       Assign a before get function to the previous get.  This function will be
  716.       called before the get takes place.
  717.  
  718.       USAGE:      int before (void (*func)(void *));
  719.  
  720.             func() will be called each time the user enters the get field.  
  721.  
  722.       The before function will be called with a void pointer to the current get
  723.       object.  This can be a int, long, double or string pointer.
  724.  
  725.       RETURNS:    W_OK  if successful.
  726.                   W_ERROR if no previous get.
  727.  
  728. =======================================
  729. get_key
  730.       Get a key from the keyboard at the current window location.  A refresh
  731.       will be automatically called if needed.  The physical cursor will be moved
  732.       to the correct window location.  You have an option of whether the key
  733.       will be echoed or not.  You can also cause a time out.
  734.  
  735.       USAGE:      int get_key (int echo = W_NOECHO, int seconds = 0);
  736.  
  737.       Optional arguments.
  738.             echo        Determine whether or not to echo the keystroke to the
  739.                         window.  default = no echo.  W_ECHO   W_NOECHO
  740.  
  741.             seconds     Max time to wait for a key.  0 is forever.
  742.  
  743.       RETURNS:    Ascii and key scan code from win.h.
  744.                   key & 0x00ff = Ascii character returned
  745.                   key >>8 = Scan code.
  746.  
  747.       EXAMPLE:
  748.             main()
  749.             {
  750.                   WinObj a;
  751.                   a.open (1, 1, 12, 40);
  752.                   a.printf ("This is a test string.");
  753.                   a.printf (2,0,"Press Escape to exit.");
  754.                   while (a.get_key() != ESC);
  755.                   a.close ();
  756.             }
  757. =======================================
  758. get
  759.       Get a variable from a screen window.  Will display each get with the
  760.       current get_attr attribute.  The compiler will determine which of the
  761.       following gets will be called.  You will have different options with
  762.       different variable types.
  763.  
  764.       USAGE:
  765.             int get (int y, int x, int &i, int len=4);
  766.                   Gets an integer from the window.  ex:  get (1, 1, i); default
  767.                   length is 4.
  768.  
  769.             int get (int y, int x, long int &i, int len=5);
  770.                   Gets a long int from the window.  ex:  get (1, 1, ld, 10);
  771.                   default length is 5.
  772.  
  773.             int get (int y, int x, double &d, int len=10, int dec=2);
  774.                   Gets a double from the window.  ex:  get (1, 1, d, 5, 1);
  775.                   Default length is 10 with 2 decimals.  The length includes the
  776.                   decimal place.  The decimal places can be from 1 to length -
  777.                   2.
  778.  
  779.             int get (int y, int x, char *str, char *picture=NULL);
  780.                   Gets a picture char string from the window.
  781.                   ex:  get (1, 1, str, "XXX-999-xxx");
  782.  
  783.             int get (int y, int x, char *str, char style, int length = 0);
  784.                   Gets a styled string from the window.  The valid styles are
  785.                   listed below.  The default length is 0.  0 uses the current
  786.                   length of the string or the predefined length of style.
  787.  
  788.             int get (int y, int x, char ch, int upper_case = 0);
  789.                   Gets a single character from the screen.  The upper case flag
  790.                   defaults to 0 which allows any character.  Any non zero value
  791.                   will force upper case.
  792.  
  793.       Valid Picture characters.
  794.             x     Allow any character.
  795.             X     Allow any character.  Letters will be converted to upper case.
  796.             a     Allow letters and spaces only.
  797.             A     Allow letters and spaces only.  Letters will be converted to
  798.                   upper case.
  799.             9     Allow numbers and spaces only.
  800.  
  801.             Any other characters in a picture clause will be forced into the
  802.             output string. ie ( , - and even spaces.
  803.  
  804.       Valid Styles:     found in WIN.H
  805.             LOWER_STYLE       convert field to 'L'owercase.
  806.             UPPER_STYLE       convert field to 'U'ppercase.
  807.             FIRST_STYLE       convert 'F'irst character to upper-case.
  808.             DATE_STYLE        MM/DD/YY date field.
  809.             SS_STYLE          999-99-9999 Social Security number field
  810.             PHONE_STYLE       (999) 999-9999 phone number.
  811.             ZIP_STYLE         99999-9999 zip code.
  812.             ANY_STYLE         any character mix.
  813.  
  814.       Notes:      If a NO picture is used the length of the string (str) will be
  815.                   used and any characters will be allowed.  This is the default.
  816.                   
  817.                   Be sure you have a NULL terminated string.
  818.  
  819.                   The length of the picture clause will override the len of the
  820.                   string.
  821.  
  822.                   If a style is used be sure the char * has enough space to
  823.                   accommodate the style type.  The length option can be used to
  824.                   control the length of the string.  However if the style is of
  825.                   a fixed length the style will override the length.  The len
  826.                   option is only useful for styles L, U, and F.  If len is 0
  827.                   the length of the string will be used for len.
  828.  
  829.       EXAMPLES:
  830.  
  831.       main
  832.       {
  833.             WinObj w;
  834.             char state[] = "  ";
  835.             long i=0;
  836.             double d;
  837.             char phone[16]="";
  838.             char name[16]="", ss[12]="";
  839.             char company[31]="";
  840.  
  841.             w.open (0, 0, 24, 79);
  842.  
  843.             w.get (10,10,state,UPPER_STYLE); // state forced to upper case.
  844.             w.get (12,10,i,3);      // get a 3 digit integer.
  845.             w.get (13,10,d);  // get a 2 decimal double, 10 chars. long
  846.             w.get (15,10,name,"Xxxxxxxxxxxxxx")  //   get a 15 char. name with
  847.                                                       the first character
  848.                                                       forced to upper.
  849.             w.get (20,10,phone,"(999) 999-9999"); //  get a phone number using
  850.                                                       a picture statement.
  851.             w.get (21,10,ss,SS_STYLE);            //  get a ss # using a
  852.                                                       style.
  853.             w.get (22,10,company,FIRST_STYLE,30);   //      get ucase string
  854.                                                             with length
  855.                                                             specified.
  856.  
  857.             w.read ();
  858.       }
  859.  
  860.       RETURNS:    W_OK if successful.
  861.                   W_ERROR if invalid x,y.
  862.                   W_NOTOPEN if window not opened.
  863.  
  864. =======================================
  865. get_button
  866.       Add a button to the get list.  Just like get () this creates an object in
  867.       a window to prompt the user for input.  The get will use the current get
  868.       attribute (see set_getattr ()) when displayed.  While reading, the user
  869.       will get to the button in order with the rest of the gets.  When a button
  870.       is the active get its attribute will be reversed, to give the user a
  871.       distinction.
  872.  
  873.       USAGE:      int get_button (int y, int x, char *str, 
  874.                                     button_func bf, int value);
  875.  
  876.             y, x        - Coordinates for the button.
  877.             str         - Button text.  Also determines size of the button
  878.             bf          - Function to call when the user press Enter or Space on
  879.                         the button.  A mouse click on the button will also cause
  880.                         this function to be called.  The function must be
  881.                         defined as 'int bf (int)'.  The function will be called
  882.                         with the value you provide.  The return value of this
  883.                         function will be stuffed into the keyboard.  If the bf
  884.                         function returns 0, the button remains active.
  885.             value       - Value to call bf with.
  886.  
  887.       RETURNS:    W_OK, W_NOTOPEN or W_ERROR.
  888.  
  889.       EXAMPLE:
  890.  
  891.             int button_press (int value)
  892.                   {
  893.                   switch (value)
  894.                         {
  895.                         case 1:
  896.                               return PGDN;      // return a normal exit
  897.                         case 2:
  898.                               return ESC;       // return an escape
  899.                         }
  900.                   }
  901.  
  902.             void main ()
  903.                   {
  904.                   WinObj w;
  905.                   w.open (....);
  906.  
  907.                   w.get (1, 1, str, UPPER_STYLE);
  908.                   w.get (3, 1, str2, LOWER_STYLE);
  909.                   w.get ....
  910.                   /* Change the attr for the buttons */
  911.                   w.set_getattr (_GREEN|BLACK);
  912.                   /* Get the buttons */
  913.                   w.get_button (1, 40, "   OK   ", button_press, 1);
  914.                   w.get_button (3, 40, " Cancel ", button_press, 2);
  915.                   /* Read from the user */
  916.                   w.read ();
  917.                   }
  918.  
  919. ===============================================
  920. get_checkbox
  921.       Add a check box to the get list.  Just like get () this creates an object
  922.       in a window to prompt the user for input.  The get will use the current
  923.       get attribute (see set_getattr ()) when displayed.  While reading, the
  924.       user will get to the check box in order with the rest of the gets.  When
  925.       a check box is the active get, it will be displayed with its getatt, to
  926.       give the user a distinction.  When it is not the current get it will be
  927.       displayed with the windows attribute at the time you called get_checkbox.
  928.  
  929.       The user can turn checks on and off by using Enter or the Space-bar.  The
  930.       box can also be toggled with the mouse.
  931.  
  932.       USAGE:  int get_checkbox (int y, int x, char *str, int &result);
  933.                   y, x        - coordinates for the upper left corner of the
  934.                               radio.
  935.                   str         - string to display as the check box
  936.                   result      - initial value of the box.  0 indicates no
  937.                               check, non zero indicates a check.  The final
  938.                               state of the check will be displayed in this int.
  939.  
  940.       RETURNS:    W_OK if get was successfull.  W_ERROR if the window was
  941.                   not opened, out of memory or some other error.
  942.  
  943.       EXAMPLES:   See DEMO2.CPP for an example.
  944.  
  945. ===============================================
  946. get_radio
  947.       Add a radio button list to the get list.  Just like get () this creates an
  948.       object in a window to prompt the user for input.  The get will use the
  949.       current get attribute (see set_getattr ()) when displayed.  While reading,
  950.       the user will get to the radio button in order with the rest of the gets. 
  951.       When a radio is the active get, the currently selected button will be
  952.       displayed in the getattr color.  The cursor will be located on that line
  953.       as well.  When it is not the current get it will be displayed with the
  954.       windows attribute at the time you called get_radio.
  955.  
  956.       The user can select only one button in your radio.  To select a button the
  957.       can cursor to the button of their choice and press Enter or Space.  The
  958.       button can also be selected with the mouse.
  959.  
  960.       USAGE:      int get_radio (int y, int x, char *button_lst, 
  961.                                     int &value, int cnt);
  962.  
  963.                   y, x        - coordinates for the upper left corner of the
  964.                               radio.
  965.                   button_lst  - list of buttons for the radio.
  966.                   value       - currently selected button (0 - (cnt-1)).  This
  967.                               is also where you'll get your return value.
  968.                   cnt         - number of buttons in the radio list.
  969.  
  970.       RETURNS:    W_OK if get was successfull.  W_ERROR if the window was
  971.                   not opened, out of memory or some other error.
  972.  
  973.       EXAMPLES:   See DEMO2.CPP for an example.
  974.  
  975. ===============================================
  976. set_getattr
  977.       Change the get attribute.  The default is _LGREY | BLACK.  This will set
  978.       the attribute for all gets to follow.  This allows you to have a different
  979.       attribute for every get.
  980.  
  981.       USAGE:      int set_getattr (int new_attr);
  982.  
  983.       RETURNS:    previous attribute.
  984.  
  985.       Note:       If new_attr < 0 then the old attribute is returned but not
  986.                   altered.
  987.  
  988. =======================================
  989. update_gets
  990.       Update display of gets.  Safe to call from within read.  This can be used
  991.       to change the value of some of the gets in a valid function.  This will
  992.       display the changes.  Warning: No pictures will be checked.  Also do not
  993.       change string lengths.
  994.  
  995.       USAGE:      int update_gets ();
  996.  
  997.       RETURNS:    W_OK or W_NOTOPEN
  998.  
  999. =======================================
  1000. valid
  1001.       Assign a valid function to the previous get.
  1002.  
  1003.       USAGE:      int valid (int (*func) (void *));
  1004.  
  1005.       func() will be called each time the user attempts to leave the get field. 
  1006.       read() will not let the user leave the current get until your valid
  1007.       function returns a non zero value.  The read function will let the user
  1008.       exit the read with a press of ESC regardless if the valid function returns
  1009.       true.
  1010.  
  1011.       The valid function will be called with a pointer to the current get
  1012.       object.  This can be a long, double or string pointer.
  1013.  
  1014.       RETURNS:    W_OK  if successful.
  1015.                   W_ERROR if no previous get.
  1016. =======================================
  1017. clear_gets
  1018.       Clear all gets for a window.  This allows you to use the get system to
  1019.       display the data but not read it from the screen.
  1020.  
  1021.       USAGE:  void clear_gets ()
  1022. =======================================
  1023. read
  1024.       Read all gets from the window object.
  1025.  
  1026.       USAGE:      int read();
  1027.  
  1028.             During the read the user can perform the following.
  1029.  
  1030.             Up/Down arrows    Move to the previous/next field.
  1031.             Shift-Tab/Tab     Move to the previous/next field.
  1032.             Enter             Move to the next field or exit the read if
  1033.                               currently on the last field.
  1034.             Right arrow       Move right one character in a string field.
  1035.             Left arrow        Move left one character in a string field.  Acts
  1036.                               like a backspace in numeric fields.
  1037.             End/Home          Move to the last/first character in a string
  1038.                               field.
  1039.             Ctrl-right/ Pan the window right/left one character.
  1040.             Ctrl-left arrow
  1041.             Ctrl-Home/        Pan the window up/down one character.
  1042.             Ctrl-End
  1043.  
  1044.       RETURNS:    Key pressed to exit read.  User can exit with an Enter on the
  1045.                   last field, Escape, PgUp or PgDn.
  1046. =======================================
  1047. any_read_change
  1048.       Allows you to test if a user made any changes during the previous read.
  1049.  
  1050.       USAGE:      int any_read_change ();
  1051.  
  1052.       RETURNS:    0 if no changes were made.
  1053.                   non zero if changes were made. Information Routines
  1054.  
  1055.  
  1056. do_youown
  1057.       Ask a window object if it owns a coordinate on the screen.  If it does
  1058.       then return the character and attribute of that coordinate.  Owning a
  1059.       coordinate means the window is the most active in that spot on the screen. 
  1060.       It is possible for a window to use a spot on the screen but not be the
  1061.       current owner.  A hidden window owns NO spots on the screen.
  1062.  
  1063.       USAGE:      int do_youown (int y, int x, char &ch, char &attr);
  1064.  
  1065.             y,x   physical screen coordinates. 0,0 origin
  1066.             ch    will return with the character if owned.
  1067.             attr  will return with the attribute if owned
  1068.  
  1069.       RETURNS:    0 if not owned.
  1070.                   1 if the window owns the coordinate.
  1071.  
  1072.       SEE:  who_owns()
  1073.  
  1074. ========================================
  1075. get_pan
  1076.       get the current virtual starting point for the displayed window.
  1077.  
  1078.       USAGE:      int get_pan (int &y, int &x)
  1079.  
  1080.             When called, get_pan will set y,x to the current start location for
  1081.             the virtual window.
  1082.  
  1083.       RETURNS:    W_OK or W_NOTOPEN.
  1084.  
  1085. ========================================
  1086. get_scr
  1087.       get the current screen location of the window.
  1088.  
  1089.       USAGE:      int get_scr (int &sr, int &sc, int &er, int &ec);
  1090.  
  1091.             When called, get_scr will set sr,sc,er,ec to the current window
  1092.             location on the screen.
  1093.  
  1094.       RETURNS:    W_OK or W_NOTOPEN
  1095.  
  1096. ========================================
  1097. get_version
  1098.       Return a pointer to the version of object windows.
  1099.  
  1100.       USAGE:      char *get_version ();
  1101.  
  1102.       RETURNS:    a pointer to "LVS Windows v##.##"
  1103.  
  1104. ========================================
  1105.  
  1106.  
  1107. is_open
  1108.       report windows open status.
  1109.  
  1110.       USAGE:      int is_open ();
  1111.  
  1112.       RETURNS:    true if open, 0 if not.
  1113.  
  1114. ========================================
  1115. max_x
  1116.       get maximum x coordinate for window.
  1117.  
  1118.       USAGE:      int max_x ();
  1119.  
  1120.       RETURNS:    max x coordinate or W_NOTOPEN if window is not opened.
  1121.  
  1122. ========================================
  1123. max_y
  1124.       get maximum y coordinate for window.
  1125.  
  1126.       USAGE:      int max_y();
  1127.  
  1128.       RETURNS:    max y coordinate or W_NOTOPEN if window is not opened.
  1129.  
  1130. ========================================
  1131. ret_char
  1132.       retrieve a character from a window object.
  1133.  
  1134.       USAGE:      int ret_attr (int y, int x);
  1135.  
  1136.             x,y   Coordinates within the window.
  1137.  
  1138.       RETURNS:    The ascii value of the character at the given window
  1139.                   coordinates.
  1140.  
  1141. ========================================
  1142. ret_attr
  1143.       retrieve an attribute from a window object.
  1144.  
  1145.       USAGE:      int ret_attr (int y,int x);
  1146.  
  1147.       RETURNS:    The attribute value of the character at the given window
  1148.                   coordinates.
  1149.  
  1150. ========================================
  1151. wherex
  1152.       Returns the current cursor column.
  1153.  
  1154.       USAGE:      int wherex ();
  1155.  
  1156.       RETURNS:    the current x coordinate
  1157.  
  1158. ========================================
  1159.  
  1160.  
  1161. wherey
  1162.       Returns the current cursor row.
  1163.  
  1164.       USAGE:      int wherey ();
  1165.  
  1166.       RETURNS:    the current y coordinate
  1167.  
  1168. ========================================
  1169. wherexy
  1170.       get the current cursor location for the window.
  1171.  
  1172.       USAGE:      int wherexy (int &y, int &x);
  1173.  
  1174.             When called, wherexy will set y,x to the current cursor coordinates
  1175.  
  1176.       RETURNS:    W_OK or W_NOTOPEN.
  1177.  
  1178. ========================================
  1179. who_owns
  1180.       Return a pointer to the window object which owns a coordinate on the
  1181.       screen.
  1182.  
  1183.       USAGE:      WinObj *who_owns (int y, int x, char &ch, char &attr);
  1184.  
  1185.             y,x   physical screen coordinates.  0,0 origin.
  1186.             ch    will return with the character if owned by anyone.
  1187.             attr  will return with the attribute if owned by anyone.
  1188.  
  1189.       RETURNS:    A pointer to the window object who owns the spot on the
  1190.                   screen.  0 if not owned.
  1191.  
  1192.                                Printer Objects
  1193.  
  1194.  
  1195.                           Declaring a Printer Object
  1196.  
  1197.       Win_Prn <Object> (char *port = "LPT1", int v_h=66,int v_w=132)
  1198.  
  1199.             port  This is the printer port to use.  The default is LPT1.  You
  1200.                   can print to any legal DOS file name.  This includes LPT2,
  1201.                   COM1, FILENAME ....
  1202.  
  1203.             v_h   This is the number of lines on a page.  The printer classes
  1204.                   uses line feeds to eject the page so this must reflect the
  1205.                   true number of lines your printer has per page.  Default is
  1206.                   66, this works for dot matrix printers.  Lasers will be less.
  1207.  
  1208.             v_w   This is the width of your printer.  This number is the max_x
  1209.                   value when using printf, puts etc.  All text will wrap beyond
  1210.                   this point.  132 is a good default even for 80 column
  1211.                   printers. The print library trims all spaces before printing,
  1212.                   so if you didn't print anything beyond column 80 your output
  1213.                   will be fine.
  1214.  
  1215.       The height and width can be changed any time the printer is not opened,
  1216.       using the same set_virtual message as in WinObj.
  1217.  
  1218.       All WinObj formatting functions are available.  printf, puts etc.  You
  1219.       even use the x/y coordinates because the page is formatted entirely in
  1220.       memory before it prints.  This allows you to skip to line 50 then back up
  1221.       to 10.  Pretty neat eh?
  1222.             
  1223.       You can even use the get/read functions.  They will print the data the
  1224.       same as they would on the screen but will not prompt the user for
  1225.       anything.
  1226.  
  1227.             EXAMPLE:
  1228.             main()
  1229.             {
  1230.                   Win_Prn p;
  1231.                   double d = 123.12;
  1232.  
  1233.                   p.open ();
  1234.                   p.printf (10, 1, "This is a test on line 10 column 1");
  1235.                   p.puts (5, 1, "Same page on line 5");
  1236.                   p.puts (40, 1, "A double get:");
  1237.                   p.get (40, 15, d);      // display a get.
  1238.                   p.print_page ();        // actually print the page.
  1239.                   p.close ();             // destructor will handle if you
  1240.                                           wish.
  1241.             }
  1242.  
  1243.  
  1244.                            Printer Object Routines
  1245.  
  1246.  
  1247. open
  1248.       Opens the printer port/file and allocates the memory needed to preprint
  1249.       the page.
  1250.  
  1251.             USAGE:      int open ();
  1252.  
  1253.             RETURNS:    W_OK
  1254.                         W_OPENED    if already open.
  1255.                         W_ERROR     misc errors.
  1256.  
  1257. ===================================
  1258. Printer Setup Definitions:
  1259.       Change the printer escape sequences which the system will use. The
  1260.       defaults are Epson codes.  They can be found in Win_Prn.hpp. Use these
  1261.       routines to change the definitions for each Win_Prn object.  Can be called
  1262.       anytime.
  1263.  
  1264.             USAGE:
  1265.                   void define_init (char *new_init);
  1266.                   void define_reset (char *new_reset);
  1267.                   void define_underline (char *new_underline);
  1268.                   void define_bold (char *new_bold);
  1269.                   void define_compress (char *new_compress);
  1270.                   void define_normal (char *new_normal);
  1271.  
  1272.             init  is called after the printer is opened.
  1273.             reset is called before the printer is closed.
  1274.  
  1275.             NOTES:      
  1276.                   If you wish to disable one of these attributes call the
  1277.                   function with a NULL.
  1278.  
  1279. ===================================
  1280. close
  1281.       Closes the printer port/file and deallocates all used memory.  This is
  1282.       called by the destructor so you may not have to.  You will want to use
  1283.       this with networks to close the queue.
  1284.             
  1285.             USAGE:      void close ();
  1286.  
  1287. ===================================
  1288. clean_page
  1289.       This gives you a clean page to work on.  All it really does is call
  1290.       clr_win ();
  1291.  
  1292.             USAGE:      void clean_page ();
  1293.  
  1294. ===================================
  1295.  
  1296.  
  1297.  
  1298. change_port
  1299.       This allows you to change printer ports/files.  You can only call this
  1300.       when the port is not opened.
  1301.  
  1302.             USAGE:      int change_port (char *new_port);
  1303.  
  1304.                   new_port    can be a printer port (LPT1, LPT2..) or any valid
  1305.                               dos file name.
  1306.  
  1307.             RETURNS:    W_OK
  1308.                         W_OPENED
  1309.  
  1310. ===================================
  1311. print_page
  1312.       This prints the page you formatted in memory.  The page is not cleared
  1313.       when it finishes.  This allows you to reprint the page or add more data to
  1314.       it if you wish.  Use any of the WinObj functions to clear or reformat the
  1315.       page.
  1316.  
  1317.  
  1318.             USAGE:      int print_page (int pages = 1);
  1319.  
  1320.                   pages       number of copies to print.
  1321.  
  1322.             RETURNS:    W_OK
  1323.                         W_NOTOPEN
  1324.                         W_ERROR
  1325.  
  1326. ===================================
  1327. set_pageattr
  1328.       This changes the print attributes for the entire page.  Can be called any
  1329.       time.  Useful when the same routines are used for painting the screen as
  1330.       are used for printing a page.  You wouldn't want your screen attributes to
  1331.       come out on the printer.
  1332.  
  1333.             USAGE:      void set_pageattr (int new_attr);
  1334.  
  1335.                   new_attr    any of the valid printer attributes. P_NORMAL,
  1336.                               P_UNDERLINE, P_COMPRESS, P_BOLD
  1337.  
  1338.             NOTES:
  1339.                   Attributes can be ored (|) together, if your printer can
  1340.                   handle them.
  1341.  
  1342.                   Use these same attributes with the WinObj set_attr () to
  1343.                   change your attributes while painting the page.
  1344.  
  1345.                                 Menu Objects
  1346.  
  1347.  
  1348.       WinMenu  <Object>
  1349.  
  1350.       Menu objects are derived from WinObj objects.  This means the window
  1351.       messages are also available to the menu objects, with a few additions to
  1352.       aid in the constructions of menus.
  1353.  
  1354.  
  1355.       There are three necessary steps to creating a menu.
  1356.             1.)   Open the menu as you would any other window.  This gives it a
  1357.                   location and color on the screen.
  1358.             2.)   Declare your menu selections.  (prompt)
  1359.             3.)   Read the menu.  This returns the user selection.
  1360.  
  1361.             EXAMPLE:
  1362.                         main()
  1363.                         {
  1364.                               WinMenu  m;
  1365.                               m.open (4, 23, 16, 53, W_SOLID,
  1366.                                       _BLUE|WHITE, _BLUE|DGREY);
  1367.                               m.title ("[ Demo Menu ]");
  1368.                               m.prompt (1, 4, 1, "Data entry");
  1369.                               m.prompt (3, 4, 2, "Moving windows");
  1370.                               m.prompt (5, 4, 3, "Random windows");
  1371.                               m.prompt (7, 4, 4, "Menu demo");
  1372.                               m.prompt (9, 4, 0, "Quit");
  1373.                               int choice = m.read (1);
  1374.                               switch (choice) 
  1375.                                     {
  1376.                                     case 1:
  1377.                                           ~~~~~~
  1378.                                           break;
  1379.                                     case 2:
  1380.                                           ~~~~~~
  1381.                                           break;
  1382.                                     ~~~~~~
  1383.                                     }
  1384.                         }
  1385.  
  1386.                                 Menu Routines
  1387.  
  1388.  
  1389.  
  1390. prompt
  1391.       declares a menu selection.  The selection will not be displayed in the
  1392.       window until you call read.
  1393.  
  1394.       USAGE:      int prompt (int y, int x, int return_val, char *str,
  1395.                               char *message = NULL, char hot_key = 0);
  1396.  
  1397.                   int prompt (int y, int x, int return_val, char *str,
  1398.                               char hot_key);
  1399.  
  1400.                   int prompt (int y, int x, WinMenu *sub, char *str,
  1401.                               char *message = NULL, char hot_key = 0);
  1402.  
  1403.                   int prompt (int y, int x, WinMenu *sub, char *str,
  1404.                               char hot_key = 0);
  1405.  
  1406.  
  1407.             y           The start row in the menu window.
  1408.             x           The start column in the menu window.
  1409.             return_val  The value you wish this selection to return.
  1410.             str         The prompt string.
  1411.             message     The message to display in the optional message box when
  1412.                         this prompt is pointed to.
  1413.             hot_key     The key the user can press to make the selection.  The
  1414.                         default is the first character of str.
  1415.             sub         A pointer to a sub menu.  This chains two menus
  1416.                         together.  The main menus .read will return the read
  1417.                         value of the submenu.  A sub menu can also have sub-
  1418.                         menus.  See demo4.cpp for an example of sub menus.
  1419.  
  1420.       RETURNS:    W_NOMEM if out of memory.
  1421.                   W_NOTOPEN if the menu has not been opened.
  1422.                   W_OK
  1423.  
  1424. ========================================
  1425. read
  1426.       Read the user selection from the menu window. The user can use the arrow
  1427.       keys to move from one selection to the next, then press Enter to make the
  1428.       selection.  The user can also press the hot letter of the menu selection. 
  1429.       The read function will also unhide a previously hidden menu object.
  1430.  
  1431.       USAGE:      int read (int start_pos);
  1432.  
  1433.             start_pos   the first selection to point to.  The read function will
  1434.                         attempt to match start_pos with one of the return_vals
  1435.                         used in the prompt function.  It will then point to this
  1436.                         selection first.
  1437.  
  1438.       RETURNS:    W_ERROR if no prompts were activated.
  1439.                   W_ESCAPE if escape was used to exit.
  1440.                   Otherwise it returns the return_val of the user selected
  1441.                   prompt.
  1442.  
  1443.       Notes:      When read is called on a menu which has sub menus, the sub
  1444.                   menus are hidden before the user is prompted.  The read will
  1445.                   not return until a prompt with a ret_value is selected by the
  1446.                   user.  If a prompt with a WinMenu * is selected by the user
  1447.                   that menu will be displayed and again prompt the user.  The
  1448.                   sub-menu path the user took will be left unhidden when the
  1449.                   read returns.  See demo4.cpp for an example of sub menus.
  1450.  
  1451.  
  1452. ========================================
  1453. reset
  1454.       This resets a menu object and closes it so you can use it again for a
  1455.       different type of menu.
  1456.  
  1457.       USAGE:      void reset ();
  1458.  
  1459. ========================================
  1460.  
  1461.  
  1462. set_barattr
  1463.       This sets the attribute for the menu selection bar.  The default is
  1464.       _LGREY|BLACK.
  1465.  
  1466.  
  1467.       USAGE:      int set_barattr (int attr);
  1468.  
  1469.       RETURNS:    the previous attribute.
  1470.  
  1471. ========================================
  1472. set_keyattr
  1473.       This sets the attribute for the hot key of a selection.  The default is
  1474.       the same attribute as the rest of the selection.
  1475.  
  1476.       USAGE:      int set_keyattr (int attr);
  1477.  
  1478.       RETURNS:    the previous attribute.
  1479.  
  1480. ========================================
  1481. set_type
  1482.       This sets the menu type, which helps control its behavior when its a sub-
  1483.       menu.
  1484.  
  1485.       USAGE:      void set_type (int new_type);
  1486.             
  1487.             valid types:      MENU_VERT   (default)
  1488.                               MENU_HORZ
  1489.                               MENU_POPUP
  1490.                               MENU_SUB
  1491.                               MENU_LOTUS
  1492.             Menu_Vert and Menu_Horz can be or-ed with one of the other types.
  1493.  
  1494. ========================================
  1495. message_line
  1496.       This sets the screen line to display a menu message.  The menu read
  1497.       message will open a 1 line window using this entire screen line.  Your
  1498.       declared messages will be displayed in this window as the user moves the
  1499.       menu bar.
  1500.  
  1501.       USAGE:      int message_line (int new_line_no);
  1502.  
  1503.       new_line_no = the line number to use.  If this is less than 0 no message
  1504.       line will be used.  The menu object default is -1;
  1505.  
  1506.       RETURNS:    the previous line number.
  1507.  
  1508.  
  1509.       EXAMPLE:
  1510.  
  1511.       main()        // A lotus style menu.
  1512.       {
  1513.             WinMenu m;
  1514.             m.open (1,0,1,79,W_NOBORDER,_BLUE|WHITE);
  1515.             m.message_line (2);
  1516.             m.prompt (0, 1,1,"Worksheet","Global, Column, Status, Delete");
  1517.             m.prompt (0,12,2,"Range","Format, Label, Erase, Justify, Prot");
  1518.             m.prompt (0,19,3,"Copy","Copy a cell or range of cells");
  1519.             m.prompt (0,25,4,"Move","Move a cell or range of cells");
  1520.             m.prompt (0,31,5,"File","Retrieve, Save, Combine, Xtract...");
  1521.             m.prompt (0,37,6,"Print","Print a worksheet to a printer or file");
  1522.             m.prompt (0,44,0,"Quit","Quit the menu demo");
  1523.  
  1524.             int choice=1;
  1525.             while (choice != 0) 
  1526.                   {
  1527.                   choice = m.read(choice);
  1528.                   switch (choice) 
  1529.                         {
  1530.                         case 1:
  1531.                               menu_demo2 ();
  1532.                               break;
  1533.                         case 2:
  1534.                               break;
  1535.                         }
  1536.                   }
  1537.       }
  1538.  
  1539. ========================================
  1540. message_attr
  1541.       Changes the attribute for the message line.  The default is _BLACK|WHITE.
  1542.  
  1543.       USAGE:      int message_attr (int new_attr);
  1544.  
  1545.       RETURNS:    the previous attribute.
  1546.  
  1547.                               Pick-List Objects
  1548.  
  1549.  
  1550.  
  1551.       WinPick  <Object>
  1552.  
  1553.       Pick-List objects are derived from WinObj objects.  This means the window
  1554.       messages are also available to the pick-list objects, with a few additions
  1555.       to aid in the construction of pick-lists.
  1556.  
  1557.       There are three necessary steps to creating a pick-list.
  1558.             1.)   Open the pick-list window the same as you would open any other
  1559.                   window.  This gives it a location and color on the screen.
  1560.             2.)   Assign a char * array to the list object.
  1561.             3.)   Read the pick list.  This returns the user selection.
  1562.  
  1563.       EXAMPLE:
  1564.             char *list[] = {  "January","February",
  1565.                               "March","April",
  1566.                               "May","June",
  1567.                               "July","August",
  1568.                               "September","October",
  1569.                               "November","December", 0 };
  1570.  
  1571.             void main()
  1572.             {
  1573.                   WinPick pl;
  1574.                   pl.open (6,41,11,53,W_DOUSIN,_BLUE|WHITE,_BLUE|BLACK);
  1575.                   pl.prompt (list);
  1576.                   int choice = pl.read();
  1577.                   WinObj w;
  1578.                   w.open (6,23,11,53,W_DOUSIN,_BLUE|WHITE,_BLUE|BLACK);
  1579.                   w.printf (1,1,"You picked %s.",list[choice]);
  1580.                   w.set_attr(_BLUE|LGREY);
  1581.                   w.printf (3,1,"Press any key to continue.");
  1582.                   w.get_key();
  1583.             }
  1584.                              Pick-List Routines
  1585.  
  1586.  
  1587.  
  1588. prompt
  1589.       assigns an array of characters pointers to the list object.  This can be
  1590.       any size list of character strings.  The last element of the list must be
  1591.       a NULL pointer, or you must provide a count of items to pick from.
  1592.  
  1593.       USAGE:      void prompt (char *list[], int count = -1);
  1594.  
  1595.             list        a pointer to the list of strings.
  1596.             count       the number of elements to pick from. (Optional) if you
  1597.                         omit this parameter the WinPick object will search for
  1598.                         a NULL to determine the end of the list.
  1599.  
  1600. ========================================
  1601. read
  1602.       Gets the users choice from the pick list.
  1603.  
  1604.       USAGE:  int read();
  1605.  
  1606.       User Keys:  
  1607.             Up, Down    Point to the Previous/Next in list
  1608.             PgUp, PgDn  Move one window page.
  1609.             Home, End.  Move to the First/Last in list
  1610.  
  1611.             A match is attempted on any other key press.  The match is to the
  1612.             first letter/number of a field.  The search is started from the next
  1613.             field to the end then back to beginning of the list.
  1614.  
  1615.       RETURNS:    the element number of the users selection.
  1616.                         W_ERROR if the list window is not opened.
  1617.                         W_ESCAPE if list is exited with an escape.
  1618.  
  1619. ========================================
  1620. set_barattr
  1621.       Sets the attribute for the pick-list bar.  The default is _LGREY|BLACK
  1622.  
  1623.       USAGE:      int set_barattr (int new_attr);
  1624.  
  1625.       RETURNS:    the previous attribute.
  1626.  
  1627.                           Paradox Related Routines
  1628.  
  1629.  
  1630. The Paradox functions work similar to the regular get/read functions.  The
  1631. exception is, these functions work directly on a Paradox record buffer, so you
  1632. need not move data from the buffers to temporary variables.  Do to the Paradox
  1633. being a large model library, these functions are available in the Large model
  1634. only.
  1635.  
  1636. EXAMPLE:
  1637.       #include <pxengine.h>
  1638.       #include "winobj.hpp"
  1639.  
  1640.       main ()
  1641.       {
  1642.             TABLEHANDLE TblHandle;
  1643.             RECORDHANDLE RecHandle;
  1644.  
  1645.             PXInit ();        // Init the PX engine
  1646.             PXTblOpen ("SALES", &TblHandle, 0, 0);    // Open the table
  1647.             PXRecBufOpen (TblHandle, &RecHandle);     // Open a record buffer
  1648.             PXRecFirst (TblHandle); // Point to the first record
  1649.             PXRecGet (TblHandle, RecHandle);    // Read the record.
  1650.  
  1651.             WinObj w;                           // my window object
  1652.  
  1653.             w.open (0, 0, 24, 79);              // Open the window
  1654.  
  1655.             w.PXrecord (TblHandle, RecHandle);  // give winobj the PX info
  1656.  
  1657.             w.PXget (1, 1, 1, 'F');       // Get the first field, style 'F'
  1658.             w.PXget (3, 1, 2, 'F');
  1659.             w.PXget (5, 1, 11, 'P');            // Get the 11 field, style
  1660.                                                 Phone
  1661.             w.PXget (7, 1, 17, 10, 2);
  1662.             w.PXget (9, 1, 18, 3, 0);
  1663.  
  1664.             w.PXread ();                        // Read the user input
  1665.  
  1666.             PXRecUpdate (TblHandle, RecHandle); // update the PX record
  1667.  
  1668.             PXExit ();  // Stop the PX engine
  1669.       }
  1670.       
  1671.  
  1672. ========================================
  1673. PXrecord
  1674.             Defines the Paradox table and record handles to LVS Windows.
  1675.             - You must first open the PX table and record buffer.
  1676.             - You must call this function before any PXget calls.
  1677.             - You can PXget data from more than one PX table by calling
  1678.               this function between the gets.
  1679.  
  1680.             USAGE:      void PXrecord(TABLEHANDLE t, RECORDHANDLE r);
  1681.  
  1682. ========================================
  1683. PXget
  1684.             Work like 'get' to define a get field on the screen.  The field is
  1685.             displayed when PXget is called.  There is more than one way to call
  1686.             a PXget.  The length of Ascii fields will be set to the length in
  1687.             the PX table.
  1688.  
  1689.             USAGE:
  1690.                   int PXget (int y, int x, FIELDHANDLE f)
  1691.                         - Generic PXget.  Used to get any field type.
  1692.                         - Strings will be of style 'A'ny character.
  1693.                         - Dates will be of style DATE_STYLE.
  1694.                         - Numbers will be input as len of 10 with 2 decimals.
  1695.  
  1696.                   int PXget (int y, int x, FIELDHANDLE f, int len, int dec)
  1697.                         - Used to input PX number fields only.  Ascii or Date
  1698.                           fields will return an error.
  1699.                         - Decimals can be from 0 - (1 less than len)
  1700.  
  1701.                   int PXget (int y, int x, FIELDHANDLE f, char style)
  1702.                         - Used to input Ascii or Date fields
  1703.                         - You can use any of the valid 'get' styles.
  1704.                         - Date fields will be forced to type 'D'.
  1705.                               
  1706.                   int PXget (int y, int x, FIELDHANDLE f, char *picture)
  1707.                         - Used to input Ascii fields only.
  1708.                         - You can use any of the valid 'get' pictures.
  1709.  
  1710.             RETURNS:
  1711.                   W_OK
  1712.                   W_ERROR     if PXrecord not called, the windows isn't open or
  1713.                               an invalid field type for the PXget.
  1714.  
  1715. ========================================
  1716. PXread
  1717.             Read the PXgets from the user.  This works just like 'read ()'.  You
  1718.             must call PXread when any of your gets are from a Paradox record
  1719.             buffer.  Not all the gets have to be of type PXget.  The PXread
  1720.             function will work on any regular get.
  1721.  
  1722.             USAGE:      int PXread ();
  1723.  
  1724.             RETURNS:    Key pressed to exit read.  User can exit with an Enter
  1725.                         on the last field, Escape, PgUp or PgDn. High Level Tools
  1726.  
  1727.  
  1728. Win_Calendar
  1729.             Display a simple calendar on the screen.  The calendar will first
  1730.             display with the current month.  The user can change the date using
  1731.             the arrow keys.  Escape or Q exits the calendar.  The calendar can
  1732.             be used in a Win_setonkey assignment.
  1733.  
  1734.             USAGE:      void Win_Calendar ();
  1735.  
  1736. ========================================
  1737. Win_Calculator
  1738.             Display a simple calculator on the screen.  This is a basic 4
  1739.             function calculator.  ( +-*/ )  Enter is the same as =.  C = Clear, 
  1740.             E = ClearEntry, S = toggle sign of result, R = Square Root of
  1741.             result.
  1742.  
  1743.             The calculator can be assigned a got key with Win_setonkey.
  1744.  
  1745.             USAGE:      void Win_Calculator ();
  1746.  
  1747. ========================================
  1748. Win_Error
  1749.             Display an error message on the screen.  Wait 10 seconds for a user
  1750.             key press to exit the message.
  1751.  
  1752.             USAGE:  void Win_Error (char *msg = "Error", 
  1753.                                     int win_attr = _RED|BLACK,
  1754.                                     int bor_attr = _RED|WHITE);
  1755.  
  1756.                   msg         Error message to display.  Default = "Error"
  1757.                   win_attr    Message window attribute.
  1758.                   bor_attr    Message window border attribute.
  1759.  
  1760. ========================================
  1761. Win_Ask_YN
  1762.             Display a message in a window and wait for a user Y or N response.
  1763.  
  1764.             USAGE:      int Win_Get_YN (char *msg = "Yes or No",
  1765.                                     int winattr = _GREEN|BLACK, 
  1766.                                     int borattr = _GREEN|BLACK);
  1767.  
  1768.                   msg         Question to ask user.
  1769.                   winattr     Window attribute.
  1770.                   borattr     Border attribute.
  1771.  
  1772. ========================================
  1773. Win_Get_Choice
  1774.             Prompt the user for a single key response.  All user responses will
  1775.             be converted to upper case.
  1776.  
  1777.             USAGE:      char Win_Get_Choice (char *msg, char *choices, 
  1778.                                           int win_attr = _GREEN|BLACK,
  1779.                                           int bor_attr = _GREEN|WHITE);
  1780.  
  1781.                   msg         Question to ask the user.
  1782.                   choices     Possible letter choices for the user.
  1783.                   winattr     Window attribute.
  1784.                   borattr     Border attributes.
  1785.  
  1786.             RETURNS:    the users response. Global Window Object Routines
  1787.  
  1788. Win_whos_active
  1789.       Returns an object pointer to the currently active window object.  This is
  1790.       a friend function to WinObj class.
  1791.  
  1792.       USAGE:      WinObj *Win_whos_active ();
  1793.  
  1794.       RETURNS:    A pointer to the currently active window or NULL if none are
  1795.                   active.
  1796.  
  1797.       EXAMPLE:
  1798.             
  1799.             WinObj *w;
  1800.  
  1801.             w = Win_whos_active ();
  1802.             w->title ("I'm the active window");
  1803. ========================================
  1804. Win_close_all
  1805.       Close all open windows.  This routine is provide to allow you to clean up
  1806.       the screen before calling the exit () function.  Normaly windows are close
  1807.       when the destructors are called.  However when you call exit() the
  1808.       destructors are not called and the windows remain open on the screen.  If
  1809.       your program exits normaly by returning to main() you won't need this
  1810.       function.  If you call exit() while any windows are open you may want to
  1811.       call this routine.
  1812.  
  1813.       USAGE:      void Win_close_all ();
  1814.                              Low Level Routines
  1815.  
  1816.  
  1817.                                Screen Functions
  1818.  
  1819.  
  1820. Win_init
  1821.       Start the low level screen system.  This is called automatically by the
  1822.       first window function used.  This function will clear the screen the first
  1823.       time it is called.  You can call this function manually to take advantage
  1824.       of the mode flags.
  1825.  
  1826.       USAGE:      void Win_init (int mode);
  1827.  
  1828.             mode: W_MONO  =   Force mono attributes only.
  1829.                   W_BIOS  =   Force bios screen writes.
  1830.                   W_DEFAULT = Auto detect the system configuration.
  1831.                   W_SNOW  =   Force CGA snow checking.
  1832.                   W_NOCLEAR = don't clear the screen during init.
  1833.  
  1834.             Any of these modes can be combined by oring.
  1835.                   example:  Win_init (W_BIOS | W_MONO);
  1836.  
  1837. ========================================
  1838. Win_clr
  1839.       Clear a section of the screen with an attribute.
  1840.       No testing is done on screen coordinates.
  1841.  
  1842.       USAGE:      void Win_clr (int sr,int sc, int er, int ec,int color);
  1843.  
  1844. ========================================
  1845. Win_clrscr
  1846.       Clear the entire display screen.
  1847.  
  1848.       USAGE:      void Win_clrscr ();
  1849.  
  1850. ========================================
  1851. Win_currentmode
  1852.       Return the current screen write modes.
  1853.       The modes returned will be | together.
  1854.  
  1855.       USAGE:      int Win_currentmode ();
  1856.  
  1857.       RETURNS:    current screen write modes.
  1858.  
  1859.       EXAMPLES:   if (Win_currentmode () & W_MONO)
  1860.                         then mono mapping is on
  1861. ========================================
  1862. Win_dispch
  1863.       Display a character on the screen.
  1864.       No coordinate testing is done.
  1865.  
  1866.       USAGE:      void Win_dispch (int y, int x, int color, char ch);
  1867.  
  1868. ========================================
  1869. Win_DesqView_Aware
  1870.       Allow your application to give up clock ticks when waiting for user input.
  1871.  
  1872.       USAGE:      int Win_DesqView_Aware ();
  1873.  
  1874.       RETURNS:    version of DesqView running.  0 if not in DesqView.
  1875.  
  1876.       Notes:      DesqView is a trade mark of Quarterdeck.
  1877. ========================================
  1878. Win_dispst
  1879.       Display a NULL terminated string on the screen.
  1880.  
  1881.       USAGE:      void Win_dispst ( int y, int x, int color, 
  1882.                                     char *str, int max );
  1883.  
  1884.             x/y         coordinates 0,0 origin.
  1885.             color       attribute.
  1886.             str         pointer to string.
  1887.             max         max number of characters to display in case string is
  1888.                         not null terminated.
  1889.  
  1890. ========================================
  1891. Win_gotoxy
  1892.       Move the cursor on the screen.  0,0 origin.
  1893.  
  1894.       USAGE:      void Win_gotoxy (int y, int x);
  1895.  
  1896. ========================================
  1897. Win_hidecur
  1898.       Hide the screen cursor.
  1899.  
  1900.       USAGE:      void Win_hidecur();
  1901.  
  1902. ========================================
  1903. Win_getpage
  1904.       Get the active video page.  Also adjust the low level video segment for
  1905.       direct screen writes.
  1906.  
  1907.       USAGE:      int Win_getpage ();
  1908.  
  1909.       RETURNS:    the number of the active page.  0-3
  1910.  
  1911. ========================================
  1912. Win_restore
  1913.       Restore a sectoin of the screen saved with Win_save.  The buffer will be
  1914.       freed by this routine.
  1915.  
  1916.       USAGE:      void Win_restore (int ulr, int ulc, int lrr, int lrc, 
  1917.                                     int *scr_data);
  1918.  
  1919.       ulr, ulc, lrr, lrc      screen coordinates.  uses sames as Win_save.
  1920.       scr_data                value returned from Win_save.
  1921.  
  1922. ========================================
  1923. Win_save
  1924.       Save a section of the screen.  This routine will allocate the memory
  1925.       needed for the save.  NULL will be returned if no memory was available.
  1926.  
  1927.       USAGE:      int *Win_save (int ulr, int ulc, int lrr, int lrc);
  1928.  
  1929.             ulr   upper left row (y)
  1930.             ulc   upper left column (x)
  1931.             lrr   lower right row (y2)
  1932.             lrc   lower right column (x2)
  1933.  
  1934.       RETURNS:    pointer to the saved screen data.  NULL if not enough memory
  1935.                   or invalid screen coordinates are used.  You will need this
  1936.                   pointer to restore the section of screen.
  1937.  
  1938. ========================================
  1939. Win_setpage
  1940.       Set the active video page.  After setting the page Win_getpage will be
  1941.       called to adjust the video segment.
  1942.  
  1943.       USAGE:      int Win_setpage (int new_page);
  1944.  
  1945.             new_page    0 - 3
  1946.  
  1947.       RETURNS:    W_OK, W_ERROR if an invalid page.
  1948.  
  1949. ========================================
  1950. Win_settabsize
  1951.       Set the tab size for printf, puts and putch.  The tab size is only in
  1952.       effect when translate is on.  The default is 4 spaces.
  1953.  
  1954.       USAGE:      int Win_settabsize ();
  1955.  
  1956.       RETURNS:    previous tab size.
  1957. ========================================
  1958. Win_showcur
  1959.       Unhide the screen cursor.
  1960.  
  1961.       USAGE:      void Win_showcur();
  1962.  
  1963. ========================================
  1964. Win_beep
  1965.       Beep the speaker.
  1966.  
  1967.       USAGE:      void Win_beep();
  1968.  
  1969. ========================================
  1970. Win_mono
  1971.       Turn black & white color re-mapping on or off.
  1972.  
  1973.       USAGE:      void Win_mono (int on_off);
  1974.  
  1975.             Call with W_ON or W_OFF
  1976. ========================================
  1977.  
  1978. Win_snow
  1979.       Turn snow checking on or off.
  1980.  
  1981.       USAGE:      void Win_snow(int on_off);
  1982.  
  1983.             Call with W_ON or W_OFF
  1984. ========================================
  1985. Win_bios
  1986.       Turn bios writes on or off.
  1987.  
  1988.       USAGE:      void Win_bios (int on_off);
  1989.  
  1990.             Call with W_ON or W_OFF
  1991.  
  1992.  
  1993.                                 VGA Functions
  1994.  
  1995. VGA_fontload
  1996.       Loads the special line drawing characters for window borders.  You can
  1997.       make this call as often as you like.  There is no undo for this call. 
  1998.       This gives your windows more of a graphic look.
  1999.  
  2000.       This routine remaps some of the seldom used line drawing characters.  It
  2001.       then calles Win_Load_Alt_Border () to point all border types at the new
  2002.       characters.
  2003.  
  2004.       This routine will do nothing if a vga color monitor is not detected.  So
  2005.       you can make the call with an monitor type.
  2006.  
  2007.       USAGE:      int VGA_fontload ();
  2008.  
  2009.       RETURNS:    W_ERROR if a non VGA-color is detected.
  2010.                   W_OK if the font was loaded.
  2011.  
  2012. ========================================
  2013. VGA_videotype
  2014.       Determines the video type.
  2015.  
  2016.       USAGE:      int VGA_video_type ();
  2017.  
  2018.       RETURNS:    V_VGA, V_EGA, V_CGA, V_MCGA, V_MONO
  2019.  
  2020. ========================================
  2021. VGA_setblink
  2022.       Toggles attribute blink mode.  Allows highlighted background on VGA
  2023.       displays.
  2024.  
  2025.       USAGE:      int VGA_set_blink (int on_off);
  2026.  
  2027.             on_off      W_ON allows blinking attributes.
  2028.                         W_OFF allows highlighted background.
  2029.  
  2030.       RETURNS:    W_OK
  2031.                   W_ERROR if not a VGA screen
  2032.  
  2033. ========================================
  2034. VGA_setlines
  2035.       Change the number of text lines per screen on VGA displays.
  2036.  
  2037.       USAGE:      int VGA_setlines (int line_cnt);
  2038.  
  2039.             line_cnt    25, 28, 43, or 50
  2040.  
  2041.       RETURNS:    W_OK
  2042.                   W_ERROR if not a VGA screen Key Functions
  2043.  
  2044.  
  2045. Win_getkey
  2046.       Get a key stroke from the keyboard.  You can have a time out on the key. 
  2047.       If the no key is pressed in the time out period 0 will be returned.
  2048.  
  2049.       USAGE:  int Win_getkey(int seconds = 0);
  2050.  
  2051.                   seconds = max time to wait for a key.
  2052.                           default = 0.  0 = wait forever.
  2053.  
  2054.       RETURNS:    scan code + ascii value of key pressed.
  2055.  
  2056.             Scan code   =   key >> 8
  2057.             ascii value =   key & 0x00ff
  2058. ========================================
  2059. Win_keystuf
  2060.       Stuff a keystroke in the internal buffer.
  2061.  
  2062.       USAGE:  int Win_keystuf (int key);
  2063.                   key    =   Scan code + ascii value of key to stuff.
  2064.  
  2065.       Key strokes are stacked not queued.  If you wish to display
  2066.       a string you must insert the keystrokes in reverse.
  2067.             Example:
  2068.                         char *str = "Keyboard stuff routine";
  2069.                         int i = strlen(str);
  2070.                         while (i)
  2071.                               Win_keystuf(str[--i]);
  2072.  
  2073.       RETURNS:    W_OK or W_ERROR if the buffers is full.
  2074.                         Buffer holds 40 keystrokes.
  2075. ========================================
  2076. Win_keywaiting
  2077.       Returns true if a key stroke is waiting.
  2078.  
  2079.       USAGE:  int Win_keywaiting ();
  2080.  
  2081.       RETURNS:  TRUE if key is waiting else false
  2082. ========================================
  2083. Win_lastkey
  2084.       Return the last key gotten by Win_getkey
  2085.  
  2086.       USAGE:  int Win_lastkey ();
  2087.  
  2088.       RETURNS:   scan code + ascii value of key gotten.
  2089. ========================================
  2090. Win_setonkey
  2091.       Assign a function to a hot key.  You may use as may hot keys
  2092.       as you like.  You can turn off a hot key by assigning the
  2093.       key to NULL.
  2094.  
  2095.       USAGE:  void Win_setonkey (int key,void (* func)(void));
  2096.       key          = scan code/ascii code combination of hot key.
  2097.                           Many of the keys are defined in WIN.H
  2098.       func        = pointer to the hot key function.  If NULL then
  2099.                           hot key will be deactivated.
  2100. ========================================
  2101. Win_setbkloop
  2102.       Assign a function to execute while waiting for a keypress.  You can only
  2103.       have one function assigned at a time.  To turn off this process assign
  2104.       NULL.
  2105.  
  2106.       USAGE:  void Win_setbkloop (void (* func)(void));
  2107.  
  2108.  
  2109.                               String Functions
  2110.  
  2111.  
  2112. str_clear
  2113.       Clears a string to a given number of spaces
  2114.  
  2115.       USAGE:      char *str_clear (char *str, int len);
  2116.             str =   String to be cleared.
  2117.             len =   New length of string.
  2118.  
  2119.       RETURNS:    a pointer to str.
  2120. ========================================
  2121. str_setsz
  2122.       Sets the size of a char string.
  2123.  
  2124.       USAGE:      char *str_setsz (char *str, int len);
  2125.  
  2126.             str =   String to be truncated or padded.
  2127.             len =   New length of string.
  2128.  
  2129.       RETURNS:    pointer to str.
  2130. ========================================
  2131. strfill
  2132.       Return a string filled with a character.
  2133.  
  2134.       USAGE:  char *strfill (char ch,int count);
  2135.  
  2136.             ch  =   character to use.
  2137.             cnt =   length of return string.  MAX of 149.
  2138.  
  2139.       RETURNS:    pointer to a static string buffer or NULL if invalid length.
  2140. ========================================
  2141. strtrim
  2142.       Trims trailing spaces from a string.
  2143.  
  2144.       USAGE:   char *strtrim (char *str);
  2145.  
  2146.       RETURNS: pointer to the string which was trimmed.
  2147.  
  2148.                               Revision History
  2149.  
  2150.  
  2151.  
  2152. vc.0  1/10/91
  2153.       First Release of LVS Windows.
  2154.  
  2155. vc.1  2/12/91
  2156.       * Added functions
  2157.             - char *get_version ()
  2158.             - int set_getattr (int)
  2159.       * Enhanced performance
  2160.       * Fixed a few misc bugs
  2161.  
  2162. v1.11a      2/25/91
  2163.             * Moved WinObj & WinPick destructor out side of include file.
  2164.             * Added Functions:
  2165.                         - int update_get ()
  2166.  
  2167. v1.12 2/28/91
  2168.             * Fixed a bug which cropped up when using BC++ in place of TC++
  2169.  
  2170. v1.2  3/05/91
  2171.             * Improved window update performance.
  2172.             * gotoxy (y,x) printf (y,x,...) and bprintf (y,x,..) have been
  2173.             modified.   When y is 1 greater than max_y () the window will scroll
  2174.             up 1 line and insert a new one at the end.
  2175.             * Added access to show_cursor ().
  2176.             * get_version () now returns a pointer to "LVS Windows v###".
  2177.  
  2178. v1.3  3/15/91
  2179.             * Added putch() and puts() as fast alternatives to printf().
  2180.             * Increased speed of update function for active window.
  2181.             * Enhanced WinPick::read ().  Added Home / End keys, also search
  2182.               for list item match to key press.
  2183.             * Fixed major bug in hide ().  Caused infinite loop.
  2184.  
  2185. v1.3a 3/20/91
  2186.             * Improved speed of update (), Win_dispch() and Win_dispatst().
  2187.  
  2188. v1.5  4/18/91
  2189.             * Renamed to LVS Windows.
  2190.             * Improved get system.
  2191.                         - Added integer get.
  2192.                         - Added before (); before get function call.
  2193.                         - Cleaned up obj pointers.
  2194.             * Added box ();  box drawing in a window
  2195.             * Added WinTools.HPP
  2196.                         - Win_Calculator ()
  2197.                         - Win_Calendar ()
  2198.                         - Win_Error ()
  2199.                         - Win_Get_YN ()
  2200.                         - Win_Get_Choice ()
  2201.             * Added seconds parameter to Win_getkey (int seconds = 0);
  2202.                         - Allows time out for key if desired.
  2203.                         - Default is 0,  (forever).
  2204.                         - This parameter also caries over to w.get_key ();
  2205.             * Now compile Win_low.c & Win_func as a c++ file.
  2206.                         - Not sure why I ever compiled as C.
  2207.             * Added len parameter to:
  2208.                   w.get (int y, int x, char *str, char style, int len);
  2209.             * Changed some key functions to virtual.
  2210.             * Added Win_Prn class. 
  2211.                         - This is a powerful printer class which gives you all
  2212.                         the output power of a WinObj object to your printer.
  2213.                         - All the printf, puts, putc and gets will format to
  2214.                         your printer like they would to the screen. (except for
  2215.                         color)
  2216.                         - Set any page size.  Paint an entire page at a time in
  2217.                         memory, then print the page.  Start with a clear page or
  2218.                         where you left off to get the next page.
  2219.                         - This print method allows random printing on a page. 
  2220.                         even with dot matrix printers.
  2221.                         - Has ability to Underline, Bold, and Compress print. 
  2222.                         The defaults are Epson codes, but you can change them.
  2223.  
  2224. v1.51 4/25/91
  2225.             * Added some PC Information functions.
  2226.                         Share_Loaded ();
  2227.                         Print_Loaded ();
  2228.                         Assign_Loaded ();
  2229.                         Himem_Loaded ();
  2230.                         Novell_Loaded ();
  2231.             * Made shadows transparent.
  2232.             * Fixed a hole in WinObj::open (), which allowed an invalid border
  2233.             type.
  2234.             * Fixed a hole in WinMenu::message, which didn't account for a null
  2235.               message.
  2236.  
  2237. v1.52   5/20/91
  2238.             * Added get () for single characters
  2239.             * Added wherey () and wherex ()
  2240.  
  2241. v1.6  6/01/91
  2242.             * Added update_all () to update all open, unhidden windows.
  2243.             * Added support for Paradox Engine reads and gets.
  2244.                   - Now you can read and get fields directly from the
  2245.                     Paradox record buffer.
  2246.                   - Added:    PXrecord (), PXget (), and PXread ();
  2247.                   - See Paradox section of doccumentation.
  2248.             * Revised Screen painter to produce support code for
  2249.               the Paradox Engine.
  2250.             * Paradox is a trademark of Borland.
  2251.  
  2252. v1.62   6/07/91
  2253.             * Added optional parameter to WinMenu.prompt ();
  2254.                   - hot key.  This allows you to select a hot key other
  2255.                     than the first key in the string.
  2256.             * Added WinMenu.set_keyattr ();
  2257.                   - Allows you to pick a different attribute for the hot key
  2258.                     in a menu.
  2259.             * Added WinObj.any_read_change ();
  2260.                   - Allows you to see if the user made any changes during
  2261.                     the last read.
  2262.  
  2263. v1.63   6/11/91
  2264.             * Win_Get_YN () now accepts an ESC as a no.
  2265.             * 'F' style in gets now changes the first letter of each word in
  2266.               a get to upper case.
  2267.  
  2268. v2.0    08/20/91
  2269.             * Added mouse support.
  2270.             * Tab/Shift Tab changes to next/previous field.
  2271.             * Changed method for inputing doubles.  and fixed bug.
  2272.             * Support for Zortech 3.0 C++ compiler.
  2273.             * 50/28 line VGA support.
  2274.             * Added border type 6.
  2275.             * add WinObj *Win_whos_active ().
  2276.             * Added overloading of << operator for output.
  2277.             * '\n' now causes a cr/lf in a window when using puts, putch, printf
  2278.             and <<.  These can be controlled with the translate flag.
  2279.             * Added printf_translate () to change translate mode.
  2280.  
  2281. v2.01    08/26/91
  2282.             * Added start parameter to pick list read ().
  2283.             * Move cursor after decimal with doubles.
  2284.             * Fixed some minor bugs.
  2285.  
  2286. v2.02    09/11/91
  2287.             * Added void Win_close_all(), to close all windows.
  2288.  
  2289. v2.1     09/27/91
  2290.             * New look for scroll bars.  more Windows like.
  2291.             * Smother border redraw routine.  Improves moves and resizeing.
  2292.             * Better grabbing routine when moving a window with the mouse.
  2293.             * Better scroll bars for Pick Lists.
  2294.  
  2295. v2.11    10/01/91
  2296.             * Added W_NOCLEAR flag to Win_init ();
  2297.             * Added Win_save() and Win_restore();
  2298.  
  2299. v2.2     10/10/91
  2300.             * Smoothed window moves and resizes.
  2301.             * Added Win_settabsize ();
  2302.             * \t no translated in printf, puts and putch
  2303.  
  2304. v2.3     10/15/91
  2305.             * the title_str parameter in title() is now copied into a buffer. 
  2306.             You can now pass a local string.
  2307.             * More VGA support -- New box drawing characters.
  2308.  
  2309. v2.31    10/25/91
  2310.             * mono attributes now map correctly for menu bars.
  2311.             * added Win_currentmode ().
  2312.  
  2313. v3.0     2/18/92
  2314.             * Added new get types:  Push Buttons, Radio Buttons & Check Boxes
  2315.             * Rewrote most of the data entry routines.  Much cleaner now, and
  2316.             more OOPS.
  2317.             * Fixed Win_save & Win_restore when in bios mode
  2318.             * Added ScreenState class for restoring previous screen modes
  2319.             * Added #define(s) for get styles
  2320.             * Added Win_keywaiting ()
  2321.             * Removed direct support for Snow Checking.  Switch still works but
  2322.             now acts like bios writes.
  2323.             * Added 43 line VGA mode.  Forces 350 scan lines.
  2324.             * Changed user pan keys to CTRL_U,D,R and L.  Now use Ctrl arrows
  2325.             for moving in data entry fields.
  2326.             * Now every get has its own attribute.  Prior to creating the get
  2327.             use set_getattr () to change its get attribute.
  2328.             * Added a new constructor to allow arrays of window objects.
  2329.             * Added Win_DesqView_Aware ().  Allows your app give up processesor
  2330.             time while waiting for user input.
  2331.  
  2332. v3.1
  2333.             * Added the ability to hide a window before opening it.  This allows
  2334.             you to paint the entire window in memory and display it later.
  2335.             * Fixed a minor bug in the menu class.
  2336.             * When a background function exists the keyboard routines now ensure
  2337.             the active window stays active, regardless what the background
  2338.             function does.
  2339.             * Added more prompt types for WinMenu objects.
  2340.             * Added true submenu support for WinMenu objects.  See demo4.cpp
  2341.             * Added allow_user_moves ().                          Index
  2342.  
  2343.  
  2344. Declaring a Window Object. . . . . . . . . . . . . . 6
  2345. Features of LVS Windows. . . . . . . . . . . . . . . 2
  2346. Files Included . . . . . . . . . . . . . . . . . . . 5
  2347. Global Window Routines . . . . . . . . . . . . . . .42
  2348.       Win_close_all. . . . . . . . . . . . . . . . .42
  2349.       Win_whos_active. . . . . . . . . . . . . . . .42
  2350. High Level Tools . . . . . . . . . . . . . . . . . .40
  2351.       Win_Ask_YN . . . . . . . . . . . . . . . . . .40
  2352.       Win_Calculator . . . . . . . . . . . . . . . .40
  2353.       Win_Calendar . . . . . . . . . . . . . . . . .40
  2354.       Win_Error. . . . . . . . . . . . . . . . . . .40
  2355.       Win_Get_Choice . . . . . . . . . . . . . . . .40
  2356. Information Routines . . . . . . . . . . . . . . . .26
  2357.       do_youown. . . . . . . . . . . . . . . . . . .26
  2358.       get_pan. . . . . . . . . . . . . . . . . . . .26
  2359.       get_scr. . . . . . . . . . . . . . . . . . . .26
  2360.       get_version. . . . . . . . . . . . . . . . . .26
  2361.       is_open. . . . . . . . . . . . . . . . . . . .26
  2362.       max_x. . . . . . . . . . . . . . . . . . . . .27
  2363.       max_y. . . . . . . . . . . . . . . . . . . . .27
  2364.       ret_attr . . . . . . . . . . . . . . . . . . .27
  2365.       ret_char . . . . . . . . . . . . . . . . . . .27
  2366.       wherex . . . . . . . . . . . . . . . . . . . .27
  2367.       wherexy. . . . . . . . . . . . . . . . . . . .28
  2368.       wherey . . . . . . . . . . . . . . . . . . . .28
  2369.       who_owns . . . . . . . . . . . . . . . . . . .28
  2370. Input Routines . . . . . . . . . . . . . . . . . . .19
  2371.       any_read_change. . . . . . . . . . . . . . . .25
  2372.       before . . . . . . . . . . . . . . . . . . . .19
  2373.       clear_gets . . . . . . . . . . . . . . . . . .24
  2374.       get. . . . . . . . . . . . . . . . . . . . . .20
  2375.       get_button . . . . . . . . . . . . . . . . . .22
  2376.       get_checkbox . . . . . . . . . . . . . . . . .23
  2377.       get_key. . . . . . . . . . . . . . . . . . . .19
  2378.       get_radio. . . . . . . . . . . . . . . . . . .23
  2379.       read . . . . . . . . . . . . . . . . . . . . .25
  2380.       set_getattr. . . . . . . . . . . . . . . . . .24
  2381.       update_gets. . . . . . . . . . . . . . . . . .24
  2382.       valid. . . . . . . . . . . . . . . . . . . . .24
  2383. Key Functions. . . . . . . . . . . . . . . . . . . .48
  2384. Low Level Routines . . . . . . . . . . . . . . . . .43
  2385.       str_clear. . . . . . . . . . . . . . . . . . .50
  2386.       str_setsz. . . . . . . . . . . . . . . . . . .50
  2387.       strfill. . . . . . . . . . . . . . . . . . . .50
  2388.       strtrim. . . . . . . . . . . . . . . . . . . .50
  2389.       VGA_fontload . . . . . . . . . . . . . . . . .47
  2390.       VGA_setblink . . . . . . . . . . . . . . . . .47
  2391.       VGA_setlines . . . . . . . . . . . . . . . . .47
  2392.       VGA_videotype. . . . . . . . . . . . . . . . .47
  2393.       Win_beep . . . . . . . . . . . . . . . . . . .45
  2394.       Win_bios . . . . . . . . . . . . . . . . . . .46
  2395.       Win_clr. . . . . . . . . . . . . . . . . . . .43
  2396.       Win_currentmode. . . . . . . . . . . . . . . .43
  2397.       Win_DesqView_Aware . . . . . . . . . . . . . .44
  2398.       Win_dispch . . . . . . . . . . . . . . . . . .43
  2399.       Win_dispst . . . . . . . . . . . . . . . . . .44
  2400.       Win_getkey . . . . . . . . . . . . . . . . . .48
  2401.       Win_getpage. . . . . . . . . . . . . . . . . .44
  2402.       Win_gotoxy . . . . . . . . . . . . . . . . . .44
  2403.       Win_hidecur. . . . . . . . . . . . . . . . . .44
  2404.       Win_init . . . . . . . . . . . . . . . . . . .43
  2405.       Win_keystuf. . . . . . . . . . . . . . . . . .48
  2406.       Win_keywaiting . . . . . . . . . . . . . . . .48
  2407.       Win_lastkey. . . . . . . . . . . . . . . . . .48
  2408.       Win_mono . . . . . . . . . . . . . . . . . . .45
  2409.       Win_restore. . . . . . . . . . . . . . . . . .44
  2410.       Win_save . . . . . . . . . . . . . . . . . . .45
  2411.       Win_setbkloop. . . . . . . . . . . . . . . . .49
  2412.       Win_setonkey . . . . . . . . . . . . . . . . .48
  2413.       Win_setpage. . . . . . . . . . . . . . . . . .45
  2414.       Win_settabsize . . . . . . . . . . . . . . . .45
  2415.       Win_showcur. . . . . . . . . . . . . . . . . .45
  2416.       Win_snow . . . . . . . . . . . . . . . . . . .46
  2417. Menu Objects . . . . . . . . . . . . . . . . . . . .32
  2418. Menu Routines. . . . . . . . . . . . . . . . . . . .33
  2419.       message_attr . . . . . . . . . . . . . . . . .35
  2420.       message_line . . . . . . . . . . . . . . . . .35
  2421.       prompt . . . . . . . . . . . . . . . . . . . .33
  2422.       read . . . . . . . . . . . . . . . . . . . . .33
  2423.       reset. . . . . . . . . . . . . . . . . . . . .34
  2424.       set_barattr. . . . . . . . . . . . . . . . . .34
  2425.       set_keyattr. . . . . . . . . . . . . . . . . .34
  2426.       set_type . . . . . . . . . . . . . . . . . . .34
  2427. Mouse Routines . . . . . . . . . . . . . . . . . . .16
  2428.       set_mouseroutine . . . . . . . . . . . . . . .18
  2429.       Win_mouse_mode . . . . . . . . . . . . . . . .18
  2430. Paradox Routines . . . . . . . . . . . . . . . . . .38
  2431.       PXget. . . . . . . . . . . . . . . . . . . . .39
  2432.       PXread . . . . . . . . . . . . . . . . . . . .39
  2433.       PXrecord . . . . . . . . . . . . . . . . . . .38
  2434. Pick-List Objects. . . . . . . . . . . . . . . . . .36
  2435. Pick-List Routines . . . . . . . . . . . . . . . . .37
  2436.       prompt . . . . . . . . . . . . . . . . . . . .37
  2437.       read . . . . . . . . . . . . . . . . . . . . .37
  2438.       set_barattr. . . . . . . . . . . . . . . . . .37
  2439. Printer Object Routines. . . . . . . . . . . . . . .30
  2440.       change_port. . . . . . . . . . . . . . . . . .31
  2441.       clean_page . . . . . . . . . . . . . . . . . .30
  2442.       close. . . . . . . . . . . . . . . . . . . . .30
  2443.       open . . . . . . . . . . . . . . . . . . . . .30
  2444.       print_page . . . . . . . . . . . . . . . . . .31
  2445.       set_pageattr . . . . . . . . . . . . . . . . .31
  2446. Printer Objects. . . . . . . . . . . . . . . . . . .29
  2447. Registration Information . . . . . . . . . . . . . . 3
  2448. Screen Functions . . . . . . . . . . . . . . . . . .43
  2449. String Functions . . . . . . . . . . . . . . . . . .50
  2450. The << operator. . . . . . . . . . . . . . . . . . .15
  2451. VGA Functions. . . . . . . . . . . . . . . . . . . .47
  2452. WinObj Routines. . . . . . . . . . . . . . . . . . . 7
  2453.       Border . . . . . . . . . . . . . . . . . . . .10
  2454.       box. . . . . . . . . . . . . . . . . . . . . . 7
  2455.       center . . . . . . . . . . . . . . . . . . . . 7
  2456.       change_border. . . . . . . . . . . . . . . . . 7
  2457.       close. . . . . . . . . . . . . . . . . . . . . 8
  2458.       clr_eol. . . . . . . . . . . . . . . . . . . . 8
  2459.       clr_win. . . . . . . . . . . . . . . . . . . . 8
  2460.       del_line . . . . . . . . . . . . . . . . . . . 8
  2461.       gotoxy . . . . . . . . . . . . . . . . . . . . 9
  2462.       hide . . . . . . . . . . . . . . . . . . . . . 9
  2463.       ins_line . . . . . . . . . . . . . . . . . . . 9
  2464.       move . . . . . . . . . . . . . . . . . . . . . 9
  2465.       open . . . . . . . . . . . . . . . . . . . . .10
  2466.       pan. . . . . . . . . . . . . . . . . . . . . .10
  2467.       printf . . . . . . . . . . . . . . . . . . . .11
  2468.       putch. . . . . . . . . . . . . . . . . . . . .11
  2469.       puts . . . . . . . . . . . . . . . . . . . . .11
  2470.       set_active . . . . . . . . . . . . . . . . . .11
  2471.       set_attr . . . . . . . . . . . . . . . . . . .12
  2472.       set_fill . . . . . . . . . . . . . . . . . . .12
  2473.       set_virtual. . . . . . . . . . . . . . . . . .12
  2474.       size . . . . . . . . . . . . . . . . . . . . .13
  2475.       title. . . . . . . . . . . . . . . . . . . . .13
  2476.       unhide . . . . . . . . . . . . . . . . . . . .13
  2477.       update . . . . . . . . . . . . . . . . . . . .13
  2478.       update_all . . . . . . . . . . . . . . . . . .14
  2479.       user_move. . . . . . . . . . . . . . . . . . .14
  2480.                                 
  2481.